notebook 7.0.0b3__py3-none-any.whl → 7.0.0rc0__py3-none-any.whl

notebook/_version.py

@@ -5,7 +5,7 @@ import re
 from collections import namedtuple
 
 # Use "hatch version xx.yy.zz" to handle version changes
-__version__ = "7.0.0b3"
+__version__ = "7.0.0rc0"
 
 # PEP440 version parser
 _version_regex = re.compile(

notebook/app.py

@@ -1,11 +1,16 @@
 """Jupyter notebook application."""
 import os
+import re
 from os.path import join as pjoin
 
 from jupyter_client.utils import ensure_async
 from jupyter_core.application import base_aliases
+from jupyter_core.paths import jupyter_config_dir
 from jupyter_server.base.handlers import JupyterHandler
-from jupyter_server.extension.handler import ExtensionHandlerJinjaMixin, ExtensionHandlerMixin
+from jupyter_server.extension.handler import (
+    ExtensionHandlerJinjaMixin,
+    ExtensionHandlerMixin,
+)
 from jupyter_server.serverapp import flags
 from jupyter_server.utils import url_escape, url_is_absolute
 from jupyter_server.utils import url_path_join as ujoin
@@ -19,7 +24,7 @@ from jupyterlab_server.config import LabConfig, get_page_config, recursive_updat
 from jupyterlab_server.handlers import _camelCase, is_url
 from notebook_shim.shim import NotebookConfigShimMixin  # type:ignore
 from tornado import web
-from traitlets import Bool, default
+from traitlets import Bool, Unicode, default
 
 from ._version import __version__
 
@@ -32,6 +37,10 @@ version = __version__
 class NotebookBaseHandler(ExtensionHandlerJinjaMixin, ExtensionHandlerMixin, JupyterHandler):
     """The base notebook API handler."""
 
+    @property
+    def custom_css(self):
+        return self.settings.get("custom_css", True)
+
     def get_page_config(self):
         """Get the page config."""
         config = LabConfig()
@@ -49,19 +58,6 @@ class NotebookBaseHandler(ExtensionHandlerJinjaMixin, ExtensionHandlerMixin, Jup
             "exposeAppInBrowser": app.expose_app_in_browser,
         }
 
-        if "hub_prefix" in app.serverapp.tornado_settings:
-            tornado_settings = app.serverapp.tornado_settings
-            hub_prefix = tornado_settings["hub_prefix"]
-            page_config["hubPrefix"] = hub_prefix
-            page_config["hubHost"] = tornado_settings["hub_host"]
-            page_config["hubUser"] = tornado_settings["user"]
-            page_config["shareUrl"] = ujoin(hub_prefix, "user-redirect")
-            # Assume the server_name property indicates running JupyterHub 1.0.
-            if hasattr(app.serverapp, "server_name"):
-                page_config["hubServerName"] = app.serverapp.server_name
-            api_token = os.getenv("JUPYTERHUB_API_TOKEN", "")
-            page_config["token"] = api_token
-
         server_root = self.settings.get("server_root_dir", "")
         server_root = server_root.replace(os.sep, "/")
         server_root = os.path.normpath(os.path.expanduser(server_root))
@@ -87,6 +83,7 @@ class NotebookBaseHandler(ExtensionHandlerJinjaMixin, ExtensionHandlerMixin, Jup
 
         page_config.setdefault("mathjaxConfig", mathjax_config)
         page_config.setdefault("fullMathjaxUrl", mathjax_url)
+        page_config.setdefault("jupyterConfigDir", jupyter_config_dir())
 
         # Put all our config in page_config
         for name in config.trait_names():
@@ -120,7 +117,7 @@ class RedirectHandler(NotebookBaseHandler):
     @web.authenticated
     def get(self):
         """Get the redirect url."""
-        return self.redirect(self.base_url + "tree")
+        return self.redirect(self.base_url.strip("/") + "/" + self.default_url.strip("/"))
 
 
 class TreeHandler(NotebookBaseHandler):
@@ -203,6 +200,27 @@ class NotebookHandler(NotebookBaseHandler):
         return self.write(tpl)
 
 
+class CustomCssHandler(NotebookBaseHandler):
+    """A custom CSS handler."""
+
+    @web.authenticated
+    def get(self):
+        """Get the custom css file."""
+
+        self.set_header("Content-Type", 'text/css')
+        page_config = self.get_page_config()
+        custom_css_file = f"{page_config['jupyterConfigDir']}/custom/custom.css"
+
+        if not os.path.isfile(custom_css_file):
+            static_path_root = re.match('^(.*?)static', page_config['staticDir'])
+            if static_path_root is not None:
+                custom_dir = static_path_root.groups()[0]
+                custom_css_file = f"{custom_dir}custom/custom.css"
+
+        with open(custom_css_file) as css_f:
+            return self.write(css_f.read())
+
+
 aliases = dict(base_aliases)
 
 
@@ -215,7 +233,7 @@ class JupyterNotebookApp(NotebookConfigShimMixin, LabServerApp):
     version = version
     app_version = version
     extension_url = "/"
-    default_url = "/tree"  # type:ignore
+    default_url = Unicode("/tree", config=True, help="The default URL to redirect to from `/`")
     file_url_prefix = "/notebooks"
     load_other_extensions = True
     app_dir = app_dir
@@ -227,12 +245,25 @@ class JupyterNotebookApp(NotebookConfigShimMixin, LabServerApp):
         help="Whether to expose the global app instance to browser via window.jupyterapp",
     )
 
+    custom_css = Bool(
+        True,
+        config=True,
+        help="""Whether custom CSS is loaded on the page.
+        Defaults to True and custom CSS is loaded.
+        """,
+    )
+
     flags = flags
     flags["expose-app-in-browser"] = (
         {"JupyterNotebookApp": {"expose_app_in_browser": True}},
         "Expose the global app instance to browser via window.jupyterapp.",
     )
 
+    flags["custom-css"] = (
+        {"JupyterNotebookApp": {"custom_css": True}},
+        "Load custom CSS in template html files. Default is True",
+    )
+
     @default("static_dir")
     def _default_static_dir(self):
         return os.path.join(HERE, "static")
@@ -261,8 +292,43 @@ class JupyterNotebookApp(NotebookConfigShimMixin, LabServerApp):
     def _default_workspaces_dir(self):
         return get_workspaces_dir()
 
+    def _prepare_templates(self):
+        super(LabServerApp, self)._prepare_templates()
+        self.jinja2_env.globals.update(custom_css=self.custom_css)  # type:ignore
+
+    def server_extension_is_enabled(self, extension):
+        """Check if server extension is enabled."""
+        try:
+            extension_enabled = (
+                self.serverapp.extension_manager.extensions[extension].enabled is True
+            )
+        except (AttributeError, KeyError, TypeError):
+            extension_enabled = False
+        return extension_enabled
+
     def initialize_handlers(self):
         """Initialize handlers."""
+        page_config = self.serverapp.web_app.settings.setdefault("page_config_data", {})
+        nbclassic_enabled = self.server_extension_is_enabled("nbclassic")
+        page_config["nbclassic_enabled"] = nbclassic_enabled
+
+        # If running under JupyterHub, add more metadata.
+        if "hub_prefix" in self.serverapp.tornado_settings:
+            tornado_settings = self.serverapp.tornado_settings
+            hub_prefix = tornado_settings["hub_prefix"]
+            page_config["hubPrefix"] = hub_prefix
+            page_config["hubHost"] = tornado_settings["hub_host"]
+            page_config["hubUser"] = tornado_settings["user"]
+            page_config["shareUrl"] = ujoin(hub_prefix, "user-redirect")
+            # Assume the server_name property indicates running JupyterHub 1.0.
+            if hasattr(self.serverapp, "server_name"):
+                page_config["hubServerName"] = self.serverapp.server_name
+            # avoid setting API token in page config
+            # $JUPYTERHUB_API_TOKEN identifies the server, not the client
+            # but at least make sure we don't use the token
+            # if the serverapp set one
+            page_config["token"] = ""
+
         self.handlers.append(
             (
                 rf"/{self.file_url_prefix}/((?!.*\.ipynb($|\?)).*)",
@@ -276,6 +342,7 @@ class JupyterNotebookApp(NotebookConfigShimMixin, LabServerApp):
         self.handlers.append(("/edit(.*)", FileHandler))
         self.handlers.append(("/consoles/(.*)", ConsoleHandler))
         self.handlers.append(("/terminals/(.*)", TerminalHandler))
+        self.handlers.append(("/custom/custom.css", CustomCssHandler))
         super().initialize_handlers()
 
     def initialize(self, argv=None):

notebook/custom/custom.css

@@ -0,0 +1,7 @@
+/*
+Placeholder for custom user CSS
+
+mainly to be overridden in profile/static/custom/custom.css
+
+This will always be an empty file
+*/